home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / basic / _memory.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  5.6 KB  |  229 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _memory.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #include <LEDA/basic.h>
  17.  
  18. //------------------------------------------------------------------------------
  19. // Memory Management
  20. //------------------------------------------------------------------------------
  21.  
  22. //const int memory_block_bytes = 4092; // size of block 2^k - 4  bytes
  23. const int memory_block_bytes = 8188; // size of block 2^13 - 4  bytes
  24. const int memory_max_size    = 255;  // maximal size of structures in bytes
  25.  
  26. memory_elem_ptr        memory_free_list[256];     //memory_max_size + 1
  27.  
  28. static long int        memory_total_count[256]; 
  29. static memory_elem_ptr memory_block_list[256];
  30. static int             memory_block_count[256];
  31. static int             memory_initialized = 0;
  32.  
  33.  
  34. static void memory_init()
  35. { for(int i = 0; i <= memory_max_size; i++)
  36.   { memory_free_list[i]   = 0;
  37.     memory_total_count[i] = 0;
  38.     memory_block_list[i]  = 0;
  39.     memory_block_count[i] = 0;
  40.    }
  41.   memory_initialized = 1;
  42.  }
  43.  
  44.  
  45. memory_elem_ptr memory_allocate_block(int b)
  46. { 
  47.   if (memory_initialized == 0) memory_init();
  48.  
  49.   if (b > memory_max_size) 
  50.      error_handler(1,string("allocate_block: size (%d bytes) too big",b));
  51.  
  52.   //allocate new block and slice it into chunks of size b bytes
  53.  
  54.   register memory_elem_ptr p;
  55.   register memory_elem_ptr stop;
  56.  
  57.   register int words = (b + sizeof(void*) - 1)/sizeof(void*);
  58.  
  59.   int bytes = words * sizeof(void*);
  60.   int num   = memory_block_bytes/bytes - 2;
  61.  
  62.   memory_block_count[b]++;
  63.   memory_total_count[b] += num;
  64.  
  65.   if ((p=memory_elem_ptr(malloc(memory_block_bytes))) == 0 )
  66.    { cout << "memory allocation: out of memory\n";
  67.      print_statistics();
  68.      exit(1);
  69.     }
  70.  
  71.   //insert block into list of used blocks
  72.   p->next = memory_block_list[b];
  73.   memory_block_list[b] = p;
  74.   p += words;
  75.  
  76.   memory_free_list[b] = p;
  77.  
  78.   stop = p + (num-1)*words;
  79.   stop->next = 0;
  80.  
  81.   while (p < stop) p = (p->next = p+words);
  82.  
  83.   return memory_free_list[b];
  84. }
  85.  
  86.  
  87. void memory_clear()
  88. { 
  89.   register memory_elem_ptr p;
  90.   int i;
  91.   long used;
  92.  
  93.   for (i=1;i<=memory_max_size;i++)
  94.   { p = memory_free_list[i];
  95.     used = memory_total_count[i];
  96.     while (p) { used--; p = p->next; }
  97.  
  98.     if (used==0)
  99.     { while (memory_block_list[i])
  100.       { p = memory_block_list[i];
  101.         memory_block_list[i] = p->next;
  102.         memory_block_count[i]--;
  103.         free((char*)p);
  104.        }
  105.       memory_free_list[i] = 0;
  106.       memory_total_count[i] = 0;
  107.      }
  108.    }
  109.  
  110. }
  111.  
  112.  
  113. void memory_kill()
  114. { register memory_elem_ptr p;
  115.   int i;
  116.  
  117.   for (i=1;i<=memory_max_size;i++)
  118.   { while (memory_block_list[i])
  119.     { p = memory_block_list[i];
  120.       memory_block_list[i] = p->next;
  121.       free((char*)p);
  122.      }
  123.     memory_free_list[i] = 0;
  124.     memory_total_count[i] = 0;
  125.     memory_block_count[i] = 0;
  126.    }
  127.  
  128.  
  129. }
  130.  
  131. memory_elem_ptr allocate_bytes(int bytes)
  132. { memory_elem_ptr p = memory_free_list[bytes];
  133.   if (p==0) p = memory_allocate_block(bytes);
  134.   memory_free_list[bytes] = p->next;
  135.   return p;
  136. }
  137.  
  138. void deallocate_bytes(void* p, int bytes)
  139. { memory_elem_ptr(p)->next = memory_free_list[bytes];
  140.   memory_free_list[bytes] = memory_elem_ptr(p);
  141.  }
  142.  
  143.  
  144. memory_elem_ptr allocate_bytes_with_check(int bytes)
  145. { memory_elem_ptr p = memory_free_list[bytes];
  146.   if (p==0) p = memory_allocate_block(bytes);
  147.   memory_free_list[bytes] = p->next;
  148.   printf("allocate(%d):   %x\n",bytes,p);
  149.   fflush(stdout);
  150.   return p;
  151. }
  152.  
  153. void deallocate_bytes_with_check(void* p, int bytes)
  154. { printf("deallocate(%d): %x\n",bytes,p);
  155.   fflush(stdout);
  156.   memory_elem_ptr q = memory_free_list[bytes];
  157.   while(q && q != memory_elem_ptr(p)) q = q->next;
  158.   if (q) error_handler(999,string("LEDA memory: pointer %d deleted twice",p));
  159.   memory_elem_ptr(p)->next = memory_free_list[bytes];
  160.   memory_free_list[bytes] = memory_elem_ptr(p);
  161.  }
  162.  
  163.  
  164. memory_elem_ptr allocate_words(int words)
  165. { int bytes = words * sizeof(void*);
  166.   memory_elem_ptr p = memory_free_list[bytes];
  167.   if (p==0) p = memory_allocate_block(bytes);
  168.   memory_free_list[bytes] = p->next;
  169.   return p;
  170. }
  171.  
  172. void deallocate_words(void* p, int words)
  173. { int bytes = words * sizeof(void*);
  174.   memory_elem_ptr(p)->next = memory_free_list[bytes];
  175.   memory_free_list[bytes] = memory_elem_ptr(p);
  176.  }
  177.  
  178.  
  179. int used_memory()
  180. { long int total_bytes=0;
  181.  
  182.   for (int i=1;i<=memory_max_size;i++)
  183.      total_bytes += i*memory_total_count[i];
  184.  
  185.   return total_bytes;
  186.  }
  187.  
  188.  
  189.  
  190. void print_statistics()
  191. {
  192.   cout.flush();
  193.  
  194.   long int total,free,used;
  195.   long int total_bytes=0, free_bytes=0, used_bytes=0, b;
  196.  
  197.  
  198.   printf("\n");
  199.   printf("\t+--------------------------------------------------+\n");
  200.   printf("\t|   size     used     free     blocks     bytes    |\n"); 
  201.   printf("\t+--------------------------------------------------+\n");
  202.  
  203.   for (int i=1;i<=memory_max_size;i++)
  204.     if ((total = memory_total_count[i]) > 0 || memory_free_list[i])
  205.     { printf("\t|   %3d    ",i);
  206.       fflush(stdout);
  207.       memory_elem_ptr p = memory_free_list[i];
  208.       free = 0;
  209.       while (p) { free++; p = p->next; }
  210.       b = total*i; 
  211.       used = total - free;
  212.       free_bytes  += free*i;
  213.       used_bytes  += used*i;
  214.       total_bytes += b;
  215.       printf("%6ld   %6ld    %6d   %8ld    |\n",
  216.               used,free,memory_block_count[i],b);
  217.      }
  218.  
  219.  float kb = float(total_bytes)/1024;
  220.  float sec = used_time();
  221.  
  222.  printf("\t+--------------------------------------------------+\n");
  223.  printf("\t|   time:%6.2f sec              space:%8.2f kb |\n",sec,kb);
  224.  printf("\t+--------------------------------------------------+\n");
  225.  printf("\n");
  226.  fflush(stdout);
  227.  
  228. }
  229.